import asyncio
# -*- coding: utf-8 -*-
"""
数据源服务模块

本模块提供统一的数据源查询接口，支持多种类型的数据查询：
- 用户信息查询
- 部门信息查询
- 会议室查询
- 知识库搜索（模拟RAG）
- 生产数据查询
- 通用API调用

所有查询都是异步的，并支持过滤器和分页功能。
"""

import json
from typing import List, Dict, Any, Optional
from datetime import datetime, timedelta
import random
from config import MOCK_USERS, MOCK_DEPARTMENTS, MOCK_MEETING_ROOMS, MOCK_KNOWLEDGE_BASE, MOCK_PRODUCTION_DATA
from models import DataSourceQuery, DataSourceResult
import logging

# 日志记录器
logger = logging.getLogger(__name__)

class DataSourceService:
    """
    数据源服务类
    
    提供统一的数据源查询接口，支持多种数据源类型的查询。
    所有查询都是异步的，支持过滤器、分页等功能。
    """
    
    def __init__(self):
        """
        初始化数据源服务
        
        加载所有模拟数据到内存中，包括：
        - users: 用户信息
        - departments: 部门信息
        - meeting_rooms: 会议室信息
        - knowledge_base: 知识库文档
        - production_data: 生产数据
        """
        self.mock_data = {
            "users": MOCK_USERS,
            "departments": MOCK_DEPARTMENTS,
            "meeting_rooms": MOCK_MEETING_ROOMS,
            "knowledge_base": MOCK_KNOWLEDGE_BASE,
            "production_data": MOCK_PRODUCTION_DATA
        }
    
    async def query_data_source(
        self,
        query: DataSourceQuery,
        user_context: Optional[Dict[str, Any]] = None
    ) -> DataSourceResult:
        """
        统一数据源查询接口
        
        Args:
            query: 数据源查询对象，包含查询类型、参数和过滤器
            user_context: 用户上下文信息（可选），用于权限控制等
            
        Returns:
            DataSourceResult: 查询结果对象，包含数据、总数和元数据
            
        Raises:
            ValueError: 当数据源类型不支持时抛出
        """
        
        try:
            if query.source_type == "user_list":
                return await self._query_users(query.query_params, query.filters)
            elif query.source_type == "department_list":
                return await self._query_departments(query.query_params, query.filters)
            elif query.source_type == "meeting_rooms":
                return await self._query_meeting_rooms(query.query_params, query.filters)
            elif query.source_type == "knowledge_base":
                return await self._query_knowledge_base(query.query_params, query.filters)
            elif query.source_type == "production_data":
                return await self._query_production_data(query.query_params, query.filters)
            elif query.source_type == "generic_api":
                return await self._query_generic_api(query.query_params, query.filters)
            else:
                raise ValueError(f"不支持的数据源类型: {query.source_type}")
                
        except Exception as e:
            logger.error(f"数据源查询失败: {e}")
            return DataSourceResult(
                source_type=query.source_type,
                data=[],
                total_count=0,
                metadata={"error": str(e)}
            )
    
    async def _query_users(
        self,
        params: Dict[str, Any],
        filters: Dict[str, Any]
    ) -> DataSourceResult:
        """
        查询用户列表
        
        支持的过滤器：
        - name: 按姓名模糊匹配
        - department: 按部门精确匹配
        - position: 按职位模糊匹配
        
        支持的查询参数：
        - limit: 返回记录数限制（默认50）
        - offset: 偏移量（默认0）
        
        Args:
            params: 查询参数字典
            filters: 过滤器字典
            
        Returns:
            DataSourceResult: 包含用户列表的查询结果
        """
        
        # 模拟异步查询延迟（实际环境中可能是数据库查询）
        await asyncio.sleep(0.1)
        
        users = self.mock_data["users"].copy()
        
        # 应用过滤器
        if filters.get("name"):
            # 按姓名模糊匹配（不区分大小写）
            name_filter = filters["name"].lower()
            users = [u for u in users if name_filter in u["name"].lower()]
        
        if filters.get("department"):
            # 按部门精确匹配
            dept_filter = filters["department"]
            users = [u for u in users if u["department"] == dept_filter]
        
        if filters.get("position"):
            # 按职位模糊匹配（不区分大小写）
            pos_filter = filters["position"].lower()
            users = [u for u in users if pos_filter in u["position"].lower()]
        
        # 应用查询参数（分页）
        limit = params.get("limit", 50)  # 默认返回50条记录
        offset = params.get("offset", 0)  # 默认从第0条开始
        
        total_count = len(users)  # 记录总数（用于分页计算）
        users = users[offset:offset + limit]  # 应用分页
        
        return DataSourceResult(
            source_type="user_list",
            data=users,
            total_count=total_count,
            metadata={
                "query_params": params,
                "filters_applied": filters
            }
        )
    
    async def _query_departments(
        self,
        params: Dict[str, Any],
        filters: Dict[str, Any]
    ) -> DataSourceResult:
        """
        查询部门列表
        
        支持的过滤器：
        - name: 按部门名称模糊匹配
        - manager: 按部门经理精确匹配
        
        支持的查询参数：
        - limit: 返回记录数限制（默认50）
        - offset: 偏移量（默认0）
        
        Args:
            params: 查询参数字典
            filters: 过滤器字典
            
        Returns:
            DataSourceResult: 包含部门列表的查询结果
        """
        
        await asyncio.sleep(0.1)
        
        departments = self.mock_data["departments"].copy()
        
        # 应用过滤器
        if filters.get("name"):
            # 按部门名称模糊匹配（不区分大小写）
            name_filter = filters["name"].lower()
            departments = [d for d in departments if name_filter in d["name"].lower()]
        
        if filters.get("manager"):
            # 按部门经理精确匹配
            manager_filter = filters["manager"]
            departments = [d for d in departments if d["manager"] == manager_filter]
        
        # 应用查询参数（分页）
        limit = params.get("limit", 50)  # 默认返回50条记录
        offset = params.get("offset", 0)  # 默认从第0条开始
        
        total_count = len(departments)  # 记录总数（用于分页计算）
        departments = departments[offset:offset + limit]  # 应用分页
        
        return DataSourceResult(
            source_type="department_list",
            data=departments,
            total_count=total_count,
            metadata={
                "query_params": params,
                "filters_applied": filters
            }
        )
    
    async def _query_meeting_rooms(
        self,
        params: Dict[str, Any],
        filters: Dict[str, Any]
    ) -> DataSourceResult:
        """
        查询会议室信息
        
        支持的过滤器：
        - capacity_min: 最小容量要求
        - equipment: 必需设备
        - available_only: 仅显示可用会议室
        - date: 查询日期
        - time_slot: 时间段
        
        Args:
            params: 查询参数字典
            filters: 过滤器字典
            
        Returns:
            DataSourceResult: 包含会议室列表的查询结果
        """
        
        await asyncio.sleep(0.1)
        
        rooms = self.mock_data["meeting_rooms"].copy()
        
        # 模拟可用性检查（实际环境中会查询预订系统）
        for room in rooms:
            # 随机生成可用性（模拟实时查询）
            room["available"] = random.choice([True, False, True, True])  # 75%可用率
            if filters.get("date") and filters.get("time_slot"):
                # 模拟特定时间段的可用性检查
                room["available"] = random.choice([True, False, True])
        
        # 应用过滤器
        if filters.get("capacity_min"):
            # 按最小容量过滤
            min_capacity = int(filters["capacity_min"])
            rooms = [r for r in rooms if r["capacity"] >= min_capacity]
        
        if filters.get("equipment"):
            # 按必需设备过滤
            required_equipment = filters["equipment"]
            rooms = [r for r in rooms if required_equipment in r["equipment"]]
        
        if filters.get("available_only") and filters["available_only"]:
            # 仅显示可用会议室
            rooms = [r for r in rooms if r["available"]]
        
        return DataSourceResult(
            source_type="meeting_rooms",
            data=rooms,
            total_count=len(rooms),
            metadata={
                "query_params": params,
                "filters_applied": filters,
                "query_time": datetime.now().isoformat()
            }
        )
    
    async def _query_knowledge_base(
        self,
        params: Dict[str, Any],
        filters: Dict[str, Any]
    ) -> DataSourceResult:
        """
        查询知识库（模拟RAG检索增强生成）
        
        实现语义搜索功能，根据查询文本匹配相关文档。
        
        支持的查询参数：
        - query: 查询文本
        - limit: 返回文档数量限制（默认5）
        
        支持的过滤器：
        - tags: 按标签过滤文档
        
        Args:
            params: 查询参数字典
            filters: 过滤器字典
            
        Returns:
            DataSourceResult: 包含相关文档的查询结果，按相关性排序
        """
        
        await asyncio.sleep(0.2)  # 模拟向量搜索延迟（实际环境中是向量数据库查询）
        
        documents = self.mock_data["knowledge_base"].copy()
        
        # 模拟语义搜索（实际环境中使用向量相似度计算）
        query_text = params.get("query", "").lower()
        if query_text:
            # 简单的关键词匹配（实际应该是向量相似度）
            scored_docs = []
            for doc in documents:
                score = 0  # 相关性得分
                content_lower = doc["content"].lower()
                title_lower = doc["title"].lower()
                
                # 标题匹配权重更高
                if query_text in title_lower:
                    score += 0.8
                
                # 内容匹配（分词匹配）
                query_words = query_text.split()
                for word in query_words:
                    if word in content_lower:
                        score += 0.3  # 内容匹配得分
                    if word in title_lower:
                        score += 0.5  # 标题匹配得分更高
                
                # 标签匹配
                for tag in doc["tags"]:
                    if query_text in tag.lower():
                        score += 0.6  # 标签匹配得分
                
                # 只保留有相关性的文档
                if score > 0:
                    doc_copy = doc.copy()
                    doc_copy["relevance_score"] = score
                    scored_docs.append(doc_copy)
            
            # 按相关性得分降序排序
            documents = sorted(scored_docs, key=lambda x: x["relevance_score"], reverse=True)
        
        # 应用过滤器
        if filters.get("tags"):
            # 按标签过滤文档
            tag_filter = filters["tags"]
            documents = [d for d in documents if any(tag in d["tags"] for tag in tag_filter)]
        
        # 限制返回数量（RAG通常返回少量高质量文档）
        limit = params.get("limit", 5)
        documents = documents[:limit]
        
        return DataSourceResult(
            source_type="knowledge_base",
            data=documents,
            total_count=len(documents),
            metadata={
                "query_params": params,
                "filters_applied": filters,
                "search_type": "semantic_search"
            }
        )
    
    async def _query_production_data(
        self,
        params: Dict[str, Any],
        filters: Dict[str, Any]
    ) -> DataSourceResult:
        """
        查询生产数据
        
        提供实时生产线数据查询，包括产量、质量率等指标。
        
        支持的过滤器：
        - line_name: 按生产线名称过滤
        - time_range: 按时间范围过滤
        
        Args:
            params: 查询参数字典
            filters: 过滤器字典
            
        Returns:
            DataSourceResult: 包含生产数据的查询结果
        """
        
        await asyncio.sleep(0.15)
        
        data = self.mock_data["production_data"].copy()
        
        # 应用过滤器
        if filters.get("line_name"):
            # 按生产线名称精确匹配
            line_filter = filters["line_name"]
            data = [d for d in data if d["line_name"] == line_filter]
        
        if filters.get("time_range"):
            # 模拟时间范围过滤（实际环境中会解析时间范围并查询数据库）
            time_range = filters["time_range"]
            # 这里简化处理，实际应该解析时间范围
            pass
        
        # 模拟实时数据更新（实际环境中从传感器或MES系统获取）
        for item in data:
            # 添加一些随机变化模拟实时数据
            item["output_count"] += random.randint(-5, 10)  # 产量变化
            item["quality_rate"] += random.uniform(-0.5, 0.5)  # 质量率变化
            item["quality_rate"] = max(95.0, min(100.0, item["quality_rate"]))  # 限制在合理范围
        
        return DataSourceResult(
            source_type="production_data",
            data=data,
            total_count=len(data),
            metadata={
                "query_params": params,
                "filters_applied": filters,
                "data_freshness": "real_time"
            }
        )
    
    async def _query_generic_api(
        self,
        params: Dict[str, Any],
        filters: Dict[str, Any]
    ) -> DataSourceResult:
        """
        通用API查询（模拟外部接口调用）
        
        模拟调用外部API获取数据，支持多种API类型。
        
        支持的API类型（通过params.api_type指定）：
        - weather: 天气数据API
        - stock: 股票数据API
        - default: 默认响应
        
        Args:
            params: 查询参数字典，包含api_type等
            filters: 过滤器字典
            
        Returns:
            DataSourceResult: 包含API响应数据的查询结果
        """
        
        await asyncio.sleep(0.3)  # 模拟网络延迟（实际环境中是HTTP请求延迟）
        
        # 模拟不同类型的API响应
        api_type = params.get("api_type", "default")
        
        if api_type == "weather":
            # 模拟天气API响应
            data = [{
                "city": "北京",
                "temperature": random.randint(15, 30),  # 温度
                "humidity": random.randint(40, 80),     # 湿度
                "weather": random.choice(["晴", "多云", "阴", "小雨"]),  # 天气状况
                "timestamp": datetime.now().isoformat()
            }]
        elif api_type == "stock":
            # 模拟股票API响应
            data = [{
                "symbol": "AAPL",  # 股票代码
                "price": round(random.uniform(150, 200), 2),    # 当前价格
                "change": round(random.uniform(-5, 5), 2),      # 涨跌幅
                "volume": random.randint(1000000, 5000000),     # 成交量
                "timestamp": datetime.now().isoformat()
            }]
        else:
            # 默认响应
            data = [{
                "message": "这是一个模拟的API响应",
                "status": "success",
                "timestamp": datetime.now().isoformat(),
                "params": params
            }]
        
        return DataSourceResult(
            source_type="generic_api",
            data=data,
            total_count=len(data),
            metadata={
                "api_type": api_type,
                "query_params": params,
                "response_time_ms": 300
            }
        )
    
    async def search_users_by_name(self, name: str) -> List[Dict[str, Any]]:
        """
        按姓名搜索用户（全局Agent使用）
        
        这是一个便捷方法，专门为全局Agent提供用户搜索功能。
        
        Args:
            name: 用户姓名（支持模糊匹配）
            
        Returns:
            List[Dict[str, Any]]: 匹配的用户列表
        """
        query = DataSourceQuery(
            source_type="user_list",
            filters={"name": name}
        )
        result = await self.query_data_source(query)
        return result.data
    
    async def search_departments_by_name(self, name: str) -> List[Dict[str, Any]]:
        """
        按名称搜索部门（全局Agent使用）
        
        这是一个便捷方法，专门为全局Agent提供部门搜索功能。
        
        Args:
            name: 部门名称（支持模糊匹配）
            
        Returns:
            List[Dict[str, Any]]: 匹配的部门列表
        """
        query = DataSourceQuery(
            source_type="department_list",
            filters={"name": name}
        )
        result = await self.query_data_source(query)
        return result.data
    
    async def search_knowledge(self, query_text: str, limit: int = 3) -> List[Dict[str, Any]]:
        """
        知识库搜索（RAG模拟）
        
        这是一个便捷方法，专门为Agent提供知识库搜索功能。
        
        Args:
            query_text: 查询文本
            limit: 返回文档数量限制（默认3）
            
        Returns:
            List[Dict[str, Any]]: 相关文档列表，按相关性排序
        """
        query = DataSourceQuery(
            source_type="knowledge_base",
            query_params={"query": query_text, "limit": limit}
        )
        result = await self.query_data_source(query)
        return result.data

# 全局数据源服务实例
# 提供给整个应用使用的单例数据源服务
data_source_service = DataSourceService()